/*
 *      Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: Chill 庄骞 (smallchill@163.com)
 */
package org.springblade.modules.demo.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.reactivex.Single;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import lombok.AllArgsConstructor;

import javax.print.DocFlavor;
import javax.validation.Valid;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.map.HashedMap;
import org.springblade.common.cache.SysCache;
import org.springblade.common.cache.UserCache;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.Func;
import org.springblade.modules.auth.utils.DateUtils;
import org.springblade.modules.demo.entity.Simp101001;
import org.springblade.modules.demo.service.HomePageProcessingService;
import org.springblade.modules.demo.service.impl.DtmExpDataSumServiceImpl;
import org.springblade.modules.demo.vo.Simp101001VO;
import org.springblade.modules.demo.wrapper.Simp101001Wrapper;
import org.springblade.modules.system.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestParam;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springblade.modules.demo.entity.DtmExpDataSum;
import org.springblade.modules.demo.vo.DtmExpDataSumVO;
import org.springblade.modules.demo.wrapper.DtmExpDataSumWrapper;
import org.springblade.modules.demo.service.IDtmExpDataSumService;
import org.springblade.core.boot.ctrl.BladeController;
import springfox.documentation.annotations.ApiIgnore;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 消费数据日统计 控制器
 *
 * @author BladeX
 * @since 2021-12-24
 */
@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("blade-demo/dtmexpdatasum")
@Api(value = "消费数据日统计", tags = "消费数据日统计接口")
public class DtmExpDataSumController extends BladeController {

	private final HomePageProcessingService homePageProcessingService;

	private final IDtmExpDataSumService dtmExpDataSumService;
	private final DtmExpDataSumServiceImpl dtmExpDataSumServiceimp;
	//变量 通过静态 注入容器

	private  static Integer  tradeCountSum=-1;			//交易次数累加值
	private static String thisTradeCountSum="-1";  //本期交易次数累加值
	private static String lastTradeCountSum="-1";	//同期交易次数累加值
	private static String lastTradeCountSum2="-1";	//上一期交易次数累加值


	private static Integer  realTicketPriceSum=-1;			//实扣金额累加值
	private static String  thisRealTicketPriceSum="-1";	//本期实扣金额累加值
	private static String  lastRealTicketPriceSum="-1"; //同期实扣金额累加值
	private static String  lastRealTicketPriceSum2="-1"; //上一期实扣金额累加值

	//上面2个同比有了 还差环比



	/**
	 * 详情
	 */
	@GetMapping("/detail")
	@ApiOperationSupport(order = 1)
	@ApiOperation(value = "详情", notes = "传入dtmExpDataSum")
	public R<DtmExpDataSumVO> detail(DtmExpDataSum dtmExpDataSum) {
		DtmExpDataSum detail = dtmExpDataSumService.getOne(Condition.getQueryWrapper(dtmExpDataSum));
		return R.data(DtmExpDataSumWrapper.build().entityVO(detail));
	}

	/**
	 * 分页 消费数据日统计
	 */
	@GetMapping("/list")
	@ApiOperationSupport(order = 2)
	@ApiOperation(value = "分页", notes = "传入dtmExpDataSum")
	public R<IPage<DtmExpDataSumVO>> list(DtmExpDataSum dtmExpDataSum, Query query) {
		IPage<DtmExpDataSum> pages = dtmExpDataSumService.page(Condition.getPage(query), Condition.getQueryWrapper(dtmExpDataSum));
		return R.data(DtmExpDataSumWrapper.build().pageVO(pages));
	}


	/**
	 * 自定义分页 消费数据日统计
	 */
	@GetMapping("/page")
	@ApiOperationSupport(order = 3)
	@ApiOperation(value = "分页", notes = "传入dtmExpDataSum")
	public R<IPage<DtmExpDataSumVO>> page(DtmExpDataSumVO dtmExpDataSum, Query query) {
		IPage<DtmExpDataSumVO> pages = dtmExpDataSumService.selectDtmExpDataSumPage(Condition.getPage(query), dtmExpDataSum);
		return R.data(pages);
	}

	/**
	 * 新增 消费数据日统计
	 */
	@PostMapping("/save")
	@ApiOperationSupport(order = 4)
	@ApiOperation(value = "新增", notes = "传入dtmExpDataSum")
	public R save(@Valid @RequestBody DtmExpDataSum dtmExpDataSum) {
		return R.status(dtmExpDataSumService.save(dtmExpDataSum));
	}

	/**
	 * 修改 消费数据日统计
	 */
	@PostMapping("/update")
	@ApiOperationSupport(order = 5)
	@ApiOperation(value = "修改", notes = "传入dtmExpDataSum")
	public R update(@Valid @RequestBody DtmExpDataSum dtmExpDataSum) {
		return R.status(dtmExpDataSumService.updateById(dtmExpDataSum));
	}

	/**
	 * 新增或修改 消费数据日统计
	 */
	@PostMapping("/submit")
	@ApiOperationSupport(order = 6)
	@ApiOperation(value = "新增或修改", notes = "传入dtmExpDataSum")
	public R submit(@Valid @RequestBody DtmExpDataSum dtmExpDataSum) {
		return R.status(dtmExpDataSumService.saveOrUpdate(dtmExpDataSum));
	}


	/**
	 * 删除 消费数据日统计
	 */
	@PostMapping("/remove")
	@ApiOperationSupport(order = 7)
	@ApiOperation(value = "逻辑删除", notes = "传入ids")
	public R remove(@ApiParam(value = "主键集合", required = true) @RequestParam String ids) {
		return R.status(dtmExpDataSumService.deleteLogic(Func.toLongList(ids)));
	}





/********************************************************************************************/





	/**
	 * 交易次数 累计和以及同比环比返回  list返回
	 * 測試接口
	 */
	@GetMapping("/list1")
	@ApiOperationSupport(order = 2)
	@ApiOperation(value = "分页", notes = "传入simp101001")
	public R list1(@ApiIgnore @RequestParam Map<String, Object> dtmExpDataSum, Query query)
	{

		//假如要List的化
		List<Map<String, Object>> list = new ArrayList<>();
		log.info("测试响应接口list1");
		//如果前端要list 也可以
		list.add(homePageProcessingService.tradeCountMap(0));

		R.data(list);
		return R.data(list);
	}



//	/**
//	 *	(暂时废弃,先只传List给前端)
//	 *  交易次数 累计和以及同比环比返回  map返回
//	 * 測試接口
//	 */
//	@GetMapping("/list2")
//	@ApiOperationSupport(order = 2)
//	@ApiOperation(value = "分页", notes = "传入simp101001")
//	public Map<String,Object> list2(@ApiIgnore @RequestParam Map<String, Object> dtmExpDataSum, Query query)
//	{
//		log.info("测试响应接口");
//		//DOTO 写一个
//		tradeCountSum= this.query1("TRADE_COUNT");
//		String 	yearOnYear=	this.yearOnYear("TRADE_COUNT");
//		String 	ringRatio=	this.ringRatio("TRADE_COUNT");
//		//假如要List的化
//		List<Map<String, String>> list = new ArrayList<>();
//		Map<String,Object> map=new HashedMap();
//		map.put("Sum0",tradeCountSum);						//交易次数累加值
//		map.put("yearOnYear0",yearOnYear);		//同比
//		map.put("ringRatio0",ringRatio);			//环比
//		//如果前端要list 也可以
//		return map;
//	}

	/**
	 * 实扣金额 累计和以及同比环比返回  list返回
	 * 測試接口
	 */
	@GetMapping("/list3")
	@ApiOperationSupport(order = 2)
	@ApiOperation(value = "分页", notes = "传入simp101001")
	public R list3(@ApiIgnore @RequestParam Map<String, Object> dtmExpDataSum, Query query)
	{
		//假如要List的化
		List<Map<String, Object>> list = new ArrayList<>();
		log.info("测试响应接口list3");
		//如果前端要list 也可以
		list.add(homePageProcessingService.realTicketPriceMap(0));
		R.data(list);
		return R.data(list);
	}

	/**
	 * 客单价 累计和以及同比环比返回  list返回
	 * 測試接口
	 */
	@GetMapping("/list4")
	@ApiOperationSupport(order = 2)
	@ApiOperation(value = "分页", notes = "传入simp101001")
	public R list4(@ApiIgnore @RequestParam Map<String, Object> dtmExpDataSum, Query query)
	{
		List<Map<String, Object>> list = new ArrayList<>();
		log.info("测试响应接口list4");

		//如果前端要list 也可以
		list.add(homePageProcessingService.unitPriceMap(0));
		R.data(list);
		return R.data(list);
	}




//	/**
//	 *返回传参 查询到的总和 其他过滤条件都是 服务商是0001, 清算时间是 2021-09-02(测试数据就这日期的)   			//TRADE_COUNT 总交易次数
//	 * SELECT sum(TRADE_COUNT) as sumAll FROM T_DTM_EXP_DATA_SUM
//	 *
//	 *
//	 * SELECT sum(TRADE_COUNT) as sumAll FROM T_DTM_EXP_DATA_SUM  WHERE LIQ_CODE='0001' and LIQ_DATE= '2021-09-02'
//	 *
//	 * */
//	public  int query1(String str){
//		DtmExpDataSum dtmExpDataSum=new DtmExpDataSum();
//		QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
//		//获取指定用户 参数2就是 具体的值  这里先写死一个
//		String data="sum("+ str + ") as sumAll";
//		//数据求和
//		queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
//		//服务商 是0001的 实际应该是查询当前账户对应的服务商
//		//TODO
//		BladeUser bladeUser= AuthUtil.getUser();
//		log.info("测试响应接口角色信息："+bladeUser);
//		AuthUtil.getUserId();
//		log.info("测试响应接口角色信息1："+AuthUtil.getUserId());
//		UserCache.getUser(AuthUtil.getUserId());
//		log.info("测试响应接口角色信息2："+UserCache.getUser(AuthUtil.getUserId()));
////		SysCache.getRoleAliases		//角色相关的
////		sysClient.getRoleAliases
//		queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","0001");
//		//清算日期是 2021-09-02  实际这里是服务器的当天时间
//		//TODO
//		String toDayDate = DateUtils.getDate() ;
//		log.info("测试响应接口toDayDate："+toDayDate);
//
//		queryWrapper.eq(/*"liqDate"*/"LIQ_DATE","2021-09-02"/*toDayDate*/);
////		//交易笔数
////		queryWrapper.eq("tradeCount","2021-09-02");
//		log.info("测试响应接口1：");
//		dtmExpDataSum=dtmExpDataSumService.getOne(queryWrapper);
//		Map<String,Object> map=dtmExpDataSumService.getMap(queryWrapper);
//		log.info("测试响应接口2"+map);
//		int a=-1;
//		try{
//			 a=	Integer.parseInt(map.get("SUMALL").toString());
//
//		}catch (NumberFormatException e){
//			e.printStackTrace();
//		}
//		return  a;
//
//		//空指针判断
////		if (dtmExpDataSum==null)
////		{
////			log.info("测试响应接口2.5：");
////			//对应处理
////			return -1;
////		}else{
////			dtmExpDataSum.setTradeCountSum(dtmExpDataSum.getTradeCountSum());
////			log.info("测试响应接口3：");
//////			dtmExpDataSum.setTradeCountSum(dtmExpDataSum.getTradeCountSum());
//////			log.info("测试响应接口1:"+dtmExpDataSum.getTradeCountSum().intValue());
////			log.info("测试响应接口3："+dtmExpDataSum.getTradeCountSum().intValue());
//////			return dtmExpDataSum.getTradeCountSum().intValue();
////		}
//	}
//
//	/**
//	 * 查询指定字段的累计和
//	 * 参数1:表里面的指定字段
//	 * 参数2: 查询的清算时间
//	 *
//	 * return:返回指定字段的 指定时间的交易次数累计和
//	 *
//	 * */
//	public  int query2(String data,String date){
//		DtmExpDataSum dtmExpDataSum=new DtmExpDataSum();
//		QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
//		//获取指定用户 参数2就是 具体的值  这里先写死一个
//		//数据求和
////		queryWrapper.select("sum(TRADE_COUNT) as sumAll");
//		String datatemp="sum("+ data /*"TRADE_COUNT"*/  +") as sumAll";
//		queryWrapper.select(datatemp);
//		//服务商 是0001的 实际应该是查询当前账户对应的服务商
//		queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","0001");
//		//清算日期是 2021-09-02  实际这里是服务器的当天时间
//		//TODO
//		queryWrapper.eq("LIQ_DATE",date);
////		//交易笔数
////		queryWrapper.eq("tradeCount","2021-09-02");
//		log.info("测试响应接口1：");
////		dtmExpDataSum=dtmExpDataSumService.getOne(queryWrapper);
//		Map<String,Object> map=dtmExpDataSumService.getMap(queryWrapper);
//		log.info("测试响应接口2"+map);
//		//查询过滤后的值为null   比如查询对比的某个日期的数据 在数据库不存在
//		if (map==null)
//		{
//			log.info("测试响应接口2.1："+map);
//			return  -1;
//		}
//		int a=-1;
//		try{
//			a=	Integer.parseInt(map.get("SUMALL").toString());
//
//		}catch (NumberFormatException e){
//			e.printStackTrace();
//		}
//		return  a;
//	}
//
//
//	/**
//	 * 同比接口
//	 * 同比：同比是上一年的比较   比如2021年9月22的数据 就是跟2020年9月22号进行比较
//	 * 参数1：比较的字段
//	 * return:返回对应的同比率
//	 *
//	 * return:返回一个map  第一个是本期数  第二个是同期数  第三个才是同比率
//	 * */
//	public  Map<String,String>  yearOnYear(String data){
//		Map<String,String> retMap=new HashedMap();
//		String thisYearDate = DateUtils.getDate();
//		String lastYearDate=(Integer.parseInt(DateUtils.getYear())-1)+"-"+  DateUtils.getMonth()+"-"+DateUtils.getDay();
//
//	    int a=  	query2(/*"TRADE_COUNT"*/data,lastYearDate);
//		int b=      query2(/*"TRADE_COUNT"*/data,thisYearDate);
//		//计算同比 同比增长率=（本期数－同期数）÷同期数×100%
//		float c= (float)(b-a)/(a);
//		log.info("同比a:"+a);
//		log.info("同比b:"+b);
//		log.info("同比c:"+c);
//		java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); percentFormat.setMaximumFractionDigits(2); //最大小数位数
//		String  retc= percentFormat.format(c);//自动转换成百分比显示..
//		log.info("同比:"+retc);
//		if ("REAL_TICKET_PRICE"==data)			//如果字段是实扣金额
//		{
//			retMap.put("thisRealTicketPriceSum",String.valueOf(b));	//本期的实扣金额累加和
//			retMap.put("lastRealTicketPriceSum",String.valueOf(a)); //同期的实扣金额累加和
//			retMap.put("RealTicketPriceYearOnYear",String.valueOf(c));				//实扣金额同比
//			return retMap;
//		}else if ("TRADE_COUNT"==data)			//如果字段是交易笔数
//		{
//			retMap.put("thisTradeCountSum",String.valueOf(b));						//本期的交易笔数累加和
//			retMap.put("lastTradeCountSum",String.valueOf(a)); 						//同期的交易笔数累加和
//			retMap.put("TradeCountYearOnYear",String.valueOf(c));					//交易笔数同比
//			return retMap;
//		}
//
//		//都没匹配上
//		return  null;
//	}
//
//	/**
//	 *
//	 * 环比接口
//	 * 环比：2个周期的变化比  一般来说是拿月为单位, 但是不排除它拿周做比较
//	 * 参数1：比较的字段
//	 * 返回参数1：本期的值
//	 * 返回参数2：上一期的值
//	 * 返回参数3：环比率
//	 * */
//	public Map<String,String>  ringRatio(String data){
//		Map<String,String> retMap=new HashedMap();
//		String currentCycleDate = DateUtils.getDate();
//		String lastCycleDate=DateUtils.getYear()+"-"+ (Integer.parseInt(DateUtils.getMonth())-1)+"-"+DateUtils.getDay();
//		int a=  	query2(/*"TRADE_COUNT"*/data,lastCycleDate);
//		int b=      query2(/*"TRADE_COUNT"*/data,currentCycleDate);
//		//计算环比  环比增长率=（本期的某个指标的值-上一期这个指标的值）/上一期这个指标的值*100%
//		float c= (float)(b-a)/a;
//		log.info("环比a:"+a);
//		log.info("环比b:"+b);
//		log.info("环比c:"+c);
//		java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); percentFormat.setMaximumFractionDigits(2); //最大小数位数
//		String  ret= percentFormat.format(c);//自动转换成百分比显示..
//		log.info("环比:"+ret);
//
//		if ("REAL_TICKET_PRICE"==data)			//如果字段是实扣金额
//		{
//			retMap.put("thisRealTicketPriceSum",String.valueOf(b));	//本期的实扣金额累加和
//			retMap.put("lastRealTicketPriceSum2",String.valueOf(a)); //上一期的实扣金额累加和
//			retMap.put("RealTicketPriceRingRatio",String.valueOf(c));//实扣金额环比
//			return retMap;
//		}else if ("TRADE_COUNT"==data)			//如果字段是交易笔数
//		{
//			retMap.put("thisTradeCountSum",String.valueOf(b));						//本期的交易笔数累加和
//			retMap.put("lastTradeCountSum2",String.valueOf(a)); 						//上一期的交易笔数累加和
//			retMap.put("TradeCountRingRatio",String.valueOf(c));					//交易笔数环比
//			return retMap;
//		}
//		return  null;
//
//	}
//




}
